/*
 * 题目描述：加油贪心问题
 *
 * 思路：1. 起点没有站那么就动不了
 *      2. 若有可行方案，那么终点前最后一站一定是，所有能够直接到达终点的站中价格最小的那个
 *      3. 递归基1：当前站为第2点钟得到的终点站，那么加油至刚刚能到达终点，算法退出
 *      4. 递归基2：当前站在加满油的情况下都无法到达下一站，那么加满油开到没有，算法退出
 *      5. 情况一：当前站加满油状态下可及范围内，当前站油价最便宜，那么加满油开往可及范围内最便宜的那个站
 *      6. 情况二：存在可及范围内比当前车站更便宜的车站
 *          6.1 子情况一：当前车辆剩余的油足够直接开到那个最便宜的站，那么不加油开过去
 *          6.2 *子情况二：当前车辆剩余的油不够开到，那么本着少在贵的地方多花钱的思想，选择加油到刚刚能开到【第一个】比当前站便宜的车站
 *      7. 递归
 */
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
struct Station{
    double price;
    int distance;
};
vector<Station> stations;
double cMax, totalDist, avg, stationNum;
int finalStation = -1;

bool cmp(Station s1, Station s2){
    return s1.distance < s2.distance;
}

void drive(int station, double gasCurrent, double price){
//    cout << station << " " << gasCurrent << " " << price << endl;
    //递归基1：若列车到达所有能在一桶油距离内到达终点的加油站中价格最低的那个加油站，那么算法结束，输出最少花费
    if (station == finalStation){
        //加油至刚好能到终点
        price += stations[station].price * (totalDist - stations[station].distance) / avg;
        printf("%.2lf", price);
        return;
    }

    double min = stations[station].price;
    int index = station;
    bool isFound = false;
    for (int i = station + 1; i < stations.size(); i++) {
        if (stations[i].distance <= stations[station].distance + cMax * avg) {
            isFound = true;
            if (stations[i].price < min) {
                min = stations[i].price;
                index = i;
            }
        }
    }
    //递归基2：如果列车在当前站的可及范围内都无法到达任何一站，那么算法结束，输出最远可达距离
    if (!isFound) {
        printf("The maximum travel distance = %.2lf", stations[station].distance + cMax * avg);
        return;
    }else{
        //情况一：当前车站油价最便宜
        if (index == station) {
            min = INT_MAX;
            index = -1;
            //那么加满油，开到其余的里面油价最便宜的车站,更新花费
            for (int i = station + 1; i < stations.size(); i++) {
                if (stations[i].distance <= stations[station].distance + cMax * avg
                    && stations[i].price < min) {
                    min = stations[i].price;
                    index = i;
                }
            }
            price += (cMax - gasCurrent) * stations[station].price;
            gasCurrent = cMax - (stations[index].distance - stations[station].distance) / avg;
            return drive(index, gasCurrent, price);
        }
            //情况二：存在比当前车站更便宜的车站
        else{
            //子情况2.1：当前剩余的油足够开到那个车站
            if ((stations[index].distance - stations[station].distance) / avg <= gasCurrent) {
                //直接开过去，不加油
                gasCurrent -= (stations[index].distance - stations[station].distance) / avg;
                return drive(index, gasCurrent, price);
            }
                //子情况2.2：当前剩余的油不够开到那个车站
            else{
                //加油至刚好开到那个最便宜的车站 【错误】
                //加油至刚好开到第一个比当前车站便宜的车站 【正确】
                for (int i = station; i < stations.size(); i++) {
                    if (stations[i].price < stations[station].price) {
                        index = i;
                        price += ((stations[index].distance - stations[station].distance) / avg - gasCurrent) *
                                 stations[station].price;
                        return drive(index, 0, price);
                    }
                }

            }
        }
    }
}
int main() {
    ios::sync_with_stdio(false);
    cin >> cMax >> totalDist >> avg >> stationNum;
    if (totalDist == 0) {
        cout << "0.00";
        return 0;
    }
    if (cMax == 0 || stationNum == 0 || avg == 0) {
        printf("The maximum travel distance = 0.00");
        return 0;
    }
    Station s;
    bool has0 = false;
    while (stationNum--) {
        cin >> s.price >> s.distance;
        if (s.distance == 0) {
            has0 = true;
        }
        stations.push_back(s);
    }
    if (!has0) {
        printf("The maximum travel distance = 0.00");
        return 0;
    }
    sort(stations.begin(), stations.end(), cmp);
    //这里需要为double，测试点4就是因为这个通过不了
    double min = INT_MAX;
    //找到所有能够直接到达终点的站中价格最少的那个，如果存在可行解那应该就是我们终点前的最后一站
    for (int i = stations.size() - 1; i >= 0; i--) {
        if (stations[i].distance + cMax * avg >= totalDist) {
            if (stations[i].price < min) {
                min = stations[i].price;
                finalStation = i;
            }
        }
    }
//    cout << "final station: " << finalStation << endl;
    drive(0, 0.0, 0.0);
    return 0;
}